//! 表元数据管理模块
//!
//! 负责表结构、索引、约束等元数据的持久化和管理

use crate::{Error, Result};
use crate::sql::Value;
use serde::{Serialize, Deserialize};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::fs::{File, OpenOptions, create_dir_all};
use std::io::{Read, Write, Seek, SeekFrom};
use std::sync::Arc;
use parking_lot::{RwLock, Mutex};
use std::time::SystemTime;

/// 表ID类型
pub type TableId = u32;

/// 索引ID类型
pub type IndexId = u32;

/// 表元数据管理器
/// 负责管理所有表的元数据信息，包括表结构、索引、约束等
#[derive(Debug)]
pub struct MetadataManager {
    /// 元数据目录
    metadata_dir: PathBuf,
    /// 表元数据映射
    tables: Arc<RwLock<HashMap<String, TableMetadata>>>,
    /// 索引元数据映射
    indexes: Arc<RwLock<HashMap<String, IndexMetadata>>>,
    /// 下一个表ID
    next_table_id: Arc<Mutex<TableId>>,
    /// 下一个索引ID
    next_index_id: Arc<Mutex<IndexId>>,
    /// 元数据文件
    metadata_file: Arc<Mutex<File>>,
}

/// 表元数据
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableMetadata {
    /// 表ID
    pub table_id: TableId,
    /// 表名
    pub table_name: String,
    /// 列定义
    pub columns: Vec<ColumnMetadata>,
    /// 主键列名
    pub primary_key: Option<String>,
    /// 外键约束
    pub foreign_keys: Vec<ForeignKeyConstraint>,
    /// 检查约束
    pub check_constraints: Vec<CheckConstraint>,
    /// 唯一约束
    pub unique_constraints: Vec<UniqueConstraint>,
    /// 表统计信息
    pub statistics: TableStatistics,
    /// 创建时间
    pub created_at: SystemTime,
    /// 最后修改时间
    pub modified_at: SystemTime,
}

/// 列元数据
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ColumnMetadata {
    /// 列名
    pub column_name: String,
    /// 数据类型
    pub data_type: DataType,
    /// 是否可为空
    pub nullable: bool,
    /// 默认值
    pub default_value: Option<Value>,
    /// 是否自增
    pub auto_increment: bool,
    /// 列注释
    pub comment: Option<String>,
    /// 列在表中的位置
    pub ordinal_position: u32,
}

/// 数据类型
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum DataType {
    /// 布尔类型
    Boolean,
    /// 8位整数
    TinyInt,
    /// 16位整数
    SmallInt,
    /// 32位整数
    Integer,
    /// 64位整数
    BigInt,
    /// 32位浮点数
    Real,
    /// 64位浮点数
    Double,
    /// 定长字符串
    Char(u32),
    /// 变长字符串
    Varchar(u32),
    /// 文本类型
    Text,
    /// 二进制数据
    Binary(u32),
    /// 变长二进制数据
    Varbinary(u32),
    /// 日期类型
    Date,
    /// 时间类型
    Time,
    /// 时间戳类型
    Timestamp,
    /// JSON类型
    Json,
    /// UUID类型
    Uuid,
    /// 小数类型
    Decimal(Option<(u8, u8)>), // 精度和小数位数
}

/// 外键约束
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForeignKeyConstraint {
    /// 约束名
    pub constraint_name: String,
    /// 本表列名
    pub column_name: String,
    /// 引用表名
    pub referenced_table: String,
    /// 引用列名
    pub referenced_column: String,
    /// 删除时动作
    pub on_delete: ReferentialAction,
    /// 更新时动作
    pub on_update: ReferentialAction,
}

/// 引用动作
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ReferentialAction {
    /// 无动作
    NoAction,
    /// 限制
    Restrict,
    /// 级联
    Cascade,
    /// 设置为NULL
    SetNull,
    /// 设置为默认值
    SetDefault,
}

/// 检查约束
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckConstraint {
    /// 约束名
    pub constraint_name: String,
    /// 检查表达式
    pub check_expression: String,
}

/// 唯一约束
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UniqueConstraint {
    /// 约束名
    pub constraint_name: String,
    /// 列名列表
    pub column_names: Vec<String>,
}

/// 表统计信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TableStatistics {
    /// 总行数
    pub row_count: u64,
    /// 数据页数
    pub page_count: u32,
    /// 平均行大小
    pub avg_row_size: u32,
    /// 表大小（字节）
    pub table_size_bytes: u64,
    /// 最后分析时间
    pub last_analyzed: Option<SystemTime>,
}

/// 索引元数据
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexMetadata {
    /// 索引ID
    pub index_id: IndexId,
    /// 索引名
    pub index_name: String,
    /// 表名
    pub table_name: String,
    /// 索引列
    pub columns: Vec<IndexColumn>,
    /// 索引类型
    pub index_type: IndexType,
    /// 是否唯一
    pub is_unique: bool,
    /// 是否主键
    pub is_primary: bool,
    /// 索引统计信息
    pub statistics: IndexStatistics,
    /// 创建时间
    pub created_at: SystemTime,
}

/// 索引列
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexColumn {
    /// 列名
    pub column_name: String,
    /// 排序方向
    pub sort_order: SortOrder,
    /// 列在索引中的位置
    pub ordinal_position: u32,
}

/// 排序方向
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SortOrder {
    /// 升序
    Ascending,
    /// 降序
    Descending,
}

/// 索引类型
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum IndexType {
    /// B+树索引
    BTree,
    /// 哈希索引
    Hash,
    /// 位图索引
    Bitmap,
    /// 全文索引
    FullText,
}

/// 索引统计信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IndexStatistics {
    /// 索引页数
    pub page_count: u32,
    /// 索引大小（字节）
    pub index_size_bytes: u64,
    /// 不同值数量
    pub distinct_values: u64,
    /// 平均键长度
    pub avg_key_length: u32,
    /// 最后分析时间
    pub last_analyzed: Option<SystemTime>,
}

impl Default for TableStatistics {
    fn default() -> Self {
        Self {
            row_count: 0,
            page_count: 0,
            avg_row_size: 0,
            table_size_bytes: 0,
            last_analyzed: None,
        }
    }
}

impl Default for IndexStatistics {
    fn default() -> Self {
        Self {
            page_count: 0,
            index_size_bytes: 0,
            distinct_values: 0,
            avg_key_length: 0,
            last_analyzed: None,
        }
    }
}

impl MetadataManager {
    /// 创建新的元数据管理器
    pub fn new<P: AsRef<Path>>(metadata_dir: P) -> Result<Self> {
        let metadata_dir = metadata_dir.as_ref().to_path_buf();

        // 确保元数据目录存在
        create_dir_all(&metadata_dir)
            .map_err(|e| Error::storage(format!("创建元数据目录失败: {}", e)))?;

        // 打开或创建元数据文件
        let metadata_file_path = metadata_dir.join("metadata.db");
        let metadata_file = OpenOptions::new()
            .create(true)
            .read(true)
            .write(true)
            .open(&metadata_file_path)
            .map_err(|e| Error::storage(format!("打开元数据文件失败: {}", e)))?;

        let manager = Self {
            metadata_dir,
            tables: Arc::new(RwLock::new(HashMap::new())),
            indexes: Arc::new(RwLock::new(HashMap::new())),
            next_table_id: Arc::new(Mutex::new(1)),
            next_index_id: Arc::new(Mutex::new(1)),
            metadata_file: Arc::new(Mutex::new(metadata_file)),
        };

        // 加载现有元数据
        manager.load_metadata()?;

        tracing::info!("元数据管理器初始化完成");
        Ok(manager)
    }

    /// 创建表
    pub fn create_table(
        &self,
        table_name: String,
        columns: Vec<ColumnMetadata>,
        primary_key: Option<String>,
    ) -> Result<TableId> {
        // 检查表名是否已存在
        {
            let tables = self.tables.read();
            if tables.contains_key(&table_name) {
                return Err(Error::storage(format!("表 '{}' 已存在", table_name)));
            }
        }

        // 验证列定义
        self.validate_columns(&columns)?;

        // 验证主键
        if let Some(ref pk_column) = primary_key {
            if !columns.iter().any(|col| col.column_name == *pk_column) {
                return Err(Error::storage(format!("主键列 '{}' 不存在", pk_column)));
            }
        }

        // 分配表ID
        let table_id = {
            let mut next_id = self.next_table_id.lock();
            let id = *next_id;
            *next_id += 1;
            id
        };

        // 创建表元数据
        let table_metadata = TableMetadata {
            table_id,
            table_name: table_name.clone(),
            columns,
            primary_key,
            foreign_keys: Vec::new(),
            check_constraints: Vec::new(),
            unique_constraints: Vec::new(),
            statistics: TableStatistics::default(),
            created_at: SystemTime::now(),
            modified_at: SystemTime::now(),
        };

        // 添加到内存映射
        {
            let mut tables = self.tables.write();
            tables.insert(table_name.clone(), table_metadata.clone());
        }

        // 持久化元数据
        self.persist_table_metadata(&table_metadata)?;

        tracing::info!("创建表 '{}' 成功，表ID: {}", table_name, table_id);
        Ok(table_id)
    }

    /// 删除表
    pub fn drop_table(&self, table_name: &str) -> Result<()> {
        // 检查表是否存在
        let table_metadata = {
            let tables = self.tables.read();
            tables.get(table_name).cloned()
        };

        let table_metadata = table_metadata
            .ok_or_else(|| Error::storage(format!("表 '{}' 不存在", table_name)))?;

        // 删除相关索引
        self.drop_table_indexes(table_name)?;

        // 从内存映射中移除
        {
            let mut tables = self.tables.write();
            tables.remove(table_name);
        }

        // 从持久化存储中删除
        self.remove_table_metadata(&table_metadata)?;

        tracing::info!("删除表 '{}' 成功", table_name);
        Ok(())
    }

    /// 获取表元数据
    pub fn get_table_metadata(&self, table_name: &str) -> Option<TableMetadata> {
        let tables = self.tables.read();
        tables.get(table_name).cloned()
    }

    /// 列出所有表
    pub fn list_tables(&self) -> Vec<String> {
        let tables = self.tables.read();
        tables.keys().cloned().collect()
    }

    /// 创建索引
    pub fn create_index(
        &self,
        index_name: String,
        table_name: String,
        columns: Vec<IndexColumn>,
        index_type: IndexType,
        is_unique: bool,
    ) -> Result<IndexId> {
        // 检查索引名是否已存在
        {
            let indexes = self.indexes.read();
            if indexes.contains_key(&index_name) {
                return Err(Error::storage(format!("索引 '{}' 已存在", index_name)));
            }
        }

        // 检查表是否存在
        {
            let tables = self.tables.read();
            if !tables.contains_key(&table_name) {
                return Err(Error::storage(format!("表 '{}' 不存在", table_name)));
            }
        }

        // 验证索引列
        self.validate_index_columns(&table_name, &columns)?;

        // 分配索引ID
        let index_id = {
            let mut next_id = self.next_index_id.lock();
            let id = *next_id;
            *next_id += 1;
            id
        };

        // 创建索引元数据
        let index_metadata = IndexMetadata {
            index_id,
            index_name: index_name.clone(),
            table_name: table_name.clone(),
            columns,
            index_type,
            is_unique,
            is_primary: false,
            statistics: IndexStatistics::default(),
            created_at: SystemTime::now(),
        };

        // 添加到内存映射
        {
            let mut indexes = self.indexes.write();
            indexes.insert(index_name.clone(), index_metadata.clone());
        }

        // 持久化元数据
        self.persist_index_metadata(&index_metadata)?;

        tracing::info!("创建索引 '{}' 成功，索引ID: {}", index_name, index_id);
        Ok(index_id)
    }

    /// 删除索引
    pub fn drop_index(&self, index_name: &str) -> Result<()> {
        // 检查索引是否存在
        let index_metadata = {
            let indexes = self.indexes.read();
            indexes.get(index_name).cloned()
        };

        let index_metadata = index_metadata
            .ok_or_else(|| Error::storage(format!("索引 '{}' 不存在", index_name)))?;

        // 从内存映射中移除
        {
            let mut indexes = self.indexes.write();
            indexes.remove(index_name);
        }

        // 从持久化存储中删除
        self.remove_index_metadata(&index_metadata)?;

        tracing::info!("删除索引 '{}' 成功", index_name);
        Ok(())
    }

    /// 获取索引元数据
    pub fn get_index_metadata(&self, index_name: &str) -> Option<IndexMetadata> {
        let indexes = self.indexes.read();
        indexes.get(index_name).cloned()
    }

    /// 获取表的所有索引
    pub fn get_table_indexes(&self, table_name: &str) -> Vec<IndexMetadata> {
        let indexes = self.indexes.read();
        indexes.values()
            .filter(|idx| idx.table_name == table_name)
            .cloned()
            .collect()
    }

    /// 验证列定义
    fn validate_columns(&self, columns: &[ColumnMetadata]) -> Result<()> {
        if columns.is_empty() {
            return Err(Error::storage("表必须至少包含一列".to_string()));
        }

        // 检查列名重复
        let mut column_names = std::collections::HashSet::new();
        for column in columns {
            if !column_names.insert(&column.column_name) {
                return Err(Error::storage(format!("列名 '{}' 重复", column.column_name)));
            }
        }

        Ok(())
    }

    /// 验证索引列
    fn validate_index_columns(&self, table_name: &str, columns: &[IndexColumn]) -> Result<()> {
        if columns.is_empty() {
            return Err(Error::storage("索引必须至少包含一列".to_string()));
        }

        // 获取表元数据
        let table_metadata = self.get_table_metadata(table_name)
            .ok_or_else(|| Error::storage(format!("表 '{}' 不存在", table_name)))?;

        // 检查索引列是否存在于表中
        for index_column in columns {
            if !table_metadata.columns.iter().any(|col| col.column_name == index_column.column_name) {
                return Err(Error::storage(format!("列 '{}' 在表 '{}' 中不存在", index_column.column_name, table_name)));
            }
        }

        Ok(())
    }

    /// 删除表的所有索引
    fn drop_table_indexes(&self, table_name: &str) -> Result<()> {
        let index_names: Vec<String> = {
            let indexes = self.indexes.read();
            indexes.values()
                .filter(|idx| idx.table_name == table_name)
                .map(|idx| idx.index_name.clone())
                .collect()
        };

        for index_name in index_names {
            self.drop_index(&index_name)?;
        }

        Ok(())
    }

    /// 加载元数据
    fn load_metadata(&self) -> Result<()> {
        let mut file = self.metadata_file.lock();

        // 获取文件大小
        let file_size = file.seek(SeekFrom::End(0))
            .map_err(|e| Error::storage(format!("获取元数据文件大小失败: {}", e)))?;

        if file_size == 0 {
            tracing::info!("元数据文件为空，跳过加载");
            return Ok(());
        }

        // 重置文件指针
        file.seek(SeekFrom::Start(0))
            .map_err(|e| Error::storage(format!("重置文件指针失败: {}", e)))?;

        // 读取文件内容
        let mut buffer = Vec::new();
        file.read_to_end(&mut buffer)
            .map_err(|e| Error::storage(format!("读取元数据文件失败: {}", e)))?;

        // 解析元数据
        match bincode::deserialize::<MetadataFile>(&buffer) {
            Ok(metadata_file) => {
                let table_count = metadata_file.tables.len();
                let index_count = metadata_file.indexes.len();

                // 加载表元数据
                {
                    let mut tables = self.tables.write();
                    for table in metadata_file.tables {
                        tables.insert(table.table_name.clone(), table);
                    }
                }

                // 加载索引元数据
                {
                    let mut indexes = self.indexes.write();
                    for index in metadata_file.indexes {
                        indexes.insert(index.index_name.clone(), index);
                    }
                }

                // 更新ID计数器
                {
                    let mut next_table_id = self.next_table_id.lock();
                    *next_table_id = metadata_file.next_table_id;
                }
                {
                    let mut next_index_id = self.next_index_id.lock();
                    *next_index_id = metadata_file.next_index_id;
                }

                tracing::info!("元数据加载完成: {} 个表，{} 个索引", table_count, index_count);
            }
            Err(e) => {
                tracing::warn!("解析元数据文件失败: {}，将重新初始化", e);
            }
        }

        Ok(())
    }

    /// 持久化表元数据
    fn persist_table_metadata(&self, _table_metadata: &TableMetadata) -> Result<()> {
        // 持久化整个元数据文件
        self.persist_all_metadata()
    }

    /// 持久化索引元数据
    fn persist_index_metadata(&self, _index_metadata: &IndexMetadata) -> Result<()> {
        // 持久化整个元数据文件
        self.persist_all_metadata()
    }

    /// 移除表元数据
    fn remove_table_metadata(&self, _table_metadata: &TableMetadata) -> Result<()> {
        // 持久化整个元数据文件
        self.persist_all_metadata()
    }

    /// 移除索引元数据
    fn remove_index_metadata(&self, _index_metadata: &IndexMetadata) -> Result<()> {
        // 持久化整个元数据文件
        self.persist_all_metadata()
    }

    /// 持久化所有元数据
    fn persist_all_metadata(&self) -> Result<()> {
        let metadata_file = {
            let tables = self.tables.read();
            let indexes = self.indexes.read();
            let next_table_id = *self.next_table_id.lock();
            let next_index_id = *self.next_index_id.lock();

            MetadataFile {
                tables: tables.values().cloned().collect(),
                indexes: indexes.values().cloned().collect(),
                next_table_id,
                next_index_id,
            }
        };

        // 序列化元数据
        let serialized = bincode::serialize(&metadata_file)
            .map_err(|e| Error::storage(format!("序列化元数据失败: {}", e)))?;

        // 写入文件
        let mut file = self.metadata_file.lock();
        file.seek(SeekFrom::Start(0))
            .map_err(|e| Error::storage(format!("重置文件指针失败: {}", e)))?;
        file.write_all(&serialized)
            .map_err(|e| Error::storage(format!("写入元数据文件失败: {}", e)))?;
        file.flush()
            .map_err(|e| Error::storage(format!("刷新元数据文件失败: {}", e)))?;

        tracing::debug!("元数据持久化完成");
        Ok(())
    }
}

/// 元数据文件格式
#[derive(Debug, Serialize, Deserialize)]
struct MetadataFile {
    /// 表元数据列表
    tables: Vec<TableMetadata>,
    /// 索引元数据列表
    indexes: Vec<IndexMetadata>,
    /// 下一个表ID
    next_table_id: TableId,
    /// 下一个索引ID
    next_index_id: IndexId,
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;
    use crate::sql::Value;

    /// 测试元数据管理器基础功能
    #[test]
    fn test_metadata_manager_basic() -> Result<()> {
        let temp_dir = TempDir::new()
            .map_err(|e| Error::storage(format!("创建临时目录失败: {}", e)))?;
        let metadata_dir = temp_dir.path().join("metadata");

        let metadata_manager = MetadataManager::new(&metadata_dir)?;

        // 测试创建表
        let columns = vec![
            ColumnMetadata {
                column_name: "id".to_string(),
                data_type: DataType::Integer,
                nullable: false,
                default_value: None,
                auto_increment: true,
                comment: Some("主键ID".to_string()),
                ordinal_position: 1,
            },
            ColumnMetadata {
                column_name: "name".to_string(),
                data_type: DataType::Varchar(100),
                nullable: false,
                default_value: None,
                auto_increment: false,
                comment: Some("用户名".to_string()),
                ordinal_position: 2,
            },
        ];

        let table_id = metadata_manager.create_table(
            "users".to_string(),
            columns,
            Some("id".to_string()),
        )?;

        assert_eq!(table_id, 1);

        // 测试获取表元数据
        let table_metadata = metadata_manager.get_table_metadata("users");
        assert!(table_metadata.is_some());

        let table_metadata = table_metadata.unwrap();
        assert_eq!(table_metadata.table_name, "users");
        assert_eq!(table_metadata.columns.len(), 2);
        assert_eq!(table_metadata.primary_key, Some("id".to_string()));

        // 测试列出所有表
        let tables = metadata_manager.list_tables();
        assert_eq!(tables.len(), 1);
        assert_eq!(tables[0], "users");

        Ok(())
    }

    /// 测试表元数据持久化
    #[test]
    fn test_table_persistence() -> Result<()> {
        let temp_dir = TempDir::new()
            .map_err(|e| Error::storage(format!("创建临时目录失败: {}", e)))?;
        let metadata_dir = temp_dir.path().join("metadata");

        // 第一阶段：创建表
        {
            let metadata_manager = MetadataManager::new(&metadata_dir)?;

            let columns = vec![
                ColumnMetadata {
                    column_name: "id".to_string(),
                    data_type: DataType::Integer,
                    nullable: false,
                    default_value: None,
                    auto_increment: true,
                    comment: Some("主键ID".to_string()),
                    ordinal_position: 1,
                },
                ColumnMetadata {
                    column_name: "email".to_string(),
                    data_type: DataType::Varchar(255),
                    nullable: true,
                    default_value: Some(Value::Text("default@example.com".to_string())),
                    auto_increment: false,
                    comment: Some("邮箱地址".to_string()),
                    ordinal_position: 2,
                },
            ];

            metadata_manager.create_table(
                "test_table".to_string(),
                columns,
                Some("id".to_string()),
            )?;
        }

        // 第二阶段：重新加载并验证
        {
            let metadata_manager = MetadataManager::new(&metadata_dir)?;

            let tables = metadata_manager.list_tables();
            assert_eq!(tables.len(), 1);
            assert_eq!(tables[0], "test_table");

            let table_metadata = metadata_manager.get_table_metadata("test_table");
            assert!(table_metadata.is_some());

            let table_metadata = table_metadata.unwrap();
            assert_eq!(table_metadata.table_name, "test_table");
            assert_eq!(table_metadata.columns.len(), 2);
            assert_eq!(table_metadata.primary_key, Some("id".to_string()));

            // 验证列信息
            let id_column = &table_metadata.columns[0];
            assert_eq!(id_column.column_name, "id");
            assert_eq!(id_column.data_type, DataType::Integer);
            assert!(!id_column.nullable);
            assert!(id_column.auto_increment);

            let email_column = &table_metadata.columns[1];
            assert_eq!(email_column.column_name, "email");
            assert_eq!(email_column.data_type, DataType::Varchar(255));
            assert!(email_column.nullable);
            assert!(!email_column.auto_increment);
            assert!(email_column.default_value.is_some());
        }

        Ok(())
    }

    /// 测试索引管理
    #[test]
    fn test_index_management() -> Result<()> {
        let temp_dir = TempDir::new()
            .map_err(|e| Error::storage(format!("创建临时目录失败: {}", e)))?;
        let metadata_dir = temp_dir.path().join("metadata");

        let metadata_manager = MetadataManager::new(&metadata_dir)?;

        // 先创建表
        let columns = vec![
            ColumnMetadata {
                column_name: "id".to_string(),
                data_type: DataType::Integer,
                nullable: false,
                default_value: None,
                auto_increment: true,
                comment: Some("主键ID".to_string()),
                ordinal_position: 1,
            },
            ColumnMetadata {
                column_name: "email".to_string(),
                data_type: DataType::Varchar(255),
                nullable: false,
                default_value: None,
                auto_increment: false,
                comment: Some("邮箱地址".to_string()),
                ordinal_position: 2,
            },
        ];

        metadata_manager.create_table(
            "users".to_string(),
            columns,
            Some("id".to_string()),
        )?;

        // 创建索引
        let index_columns = vec![
            IndexColumn {
                column_name: "email".to_string(),
                sort_order: SortOrder::Ascending,
                ordinal_position: 1,
            }
        ];

        let index_id = metadata_manager.create_index(
            "idx_users_email".to_string(),
            "users".to_string(),
            index_columns,
            IndexType::BTree,
            true, // 唯一索引
        )?;

        assert_eq!(index_id, 1);

        // 测试获取表的索引
        let indexes = metadata_manager.get_table_indexes("users");
        assert_eq!(indexes.len(), 1);

        let index = &indexes[0];
        assert_eq!(index.index_name, "idx_users_email");
        assert_eq!(index.table_name, "users");
        assert_eq!(index.index_type, IndexType::BTree);
        assert!(index.is_unique);
        assert_eq!(index.columns.len(), 1);
        assert_eq!(index.columns[0].column_name, "email");

        Ok(())
    }
}
